home *** CD-ROM | disk | FTP | other *** search
/ The AGA Experience 3 / AGA Experience Volume 3 (1997)(NFA - SAdENESS)[!].iso / software / utilities / graphics / rtgmaster / devdocs / rtgmaster.ad < prev    next >
Encoding:
Text File  |  1996-11-01  |  82.2 KB  |  2,149 lines

  1. rtgmaster.library/CallRtgC2P                                rtgmaster.library/CallRtgC2P
  2.  
  3.    NAME
  4.         CallRtgC2P -- Perform c2p for Planar Screens, CopyRtgPixelArray for Chunky Screens
  5.  
  6.    SYNOPSIS
  7.         int CallRtgC2P(RtgScreen,BufAdr,Array,signal,xpos,ypos,width,height,mode)
  8.          D0              A0        A1     A2    D0     D1   D2   D3    D4     D5
  9.  
  10.         int CallRtgC2P(struct RtgScreen *,APTR,APTR,ULONG,ULONG,ULONG,ULONG,ULONG,ULONG)
  11.  
  12.    FUNCTION
  13.         This function will look what the "standard c2p" for the system is up to now
  14.         (the standard c2p can be choose by a future version of the Rtgmaster Screenmode
  15.         requester, the available c2p algorithms are found in libs:rtgc2p, how own c2p
  16.         algorithms can be added to the system will be explained in the documentation
  17.         of the first version of rtgmaster.library that actually supports CallRtgC2P).
  18.         The function will, if the display is a Planar one, convert the Chunky Data in
  19.         Array to Planar using the choosen c2p algorithm, and display it in the choosen
  20.         Buffer. For Chunky Displays it will instead do the same as CopyRtgChunkyPixel.
  21.         This way a very easy possibility to support both AGA and Graphics Boards without
  22.         having to do "special versions" will be available, if one uses a Fastram Buffer.
  23.  
  24.         I am still looking for c2p algorithms for this function !!! All used c2p algorithms
  25.         should support AGA and additional, it would be fine, if they supported
  26.         1x1,1x2,2x1 and 2x2. If you have fine c2p algorithms, mail me
  27.         (MagicSN@birdland.es.bawue.de).
  28.  
  29.         NOTE : The Array should EXACTLY be as big as specified with Left, Top, Width
  30.         and Height... it should *NOT* be bigger.
  31.  
  32.         NOTE: Currently you *HAVE TO* use xpos=0 ypos=0 width=<max x> height=<max y>
  33.         Maybe this will change in the future !!!!!!!!!!!!!! This is only because i do
  34.         not have ANY c2p that supports that feature up to now...
  35.  
  36.         NOTE: Some c2p algorithms might do NOTHING in certain colour depths, chunky modes
  37.         or for interleaved bitmaps. Be careful about this. If the c2p works,
  38.         this function returns 0, otherwise an errorcode.
  39.  
  40.         Principially it COULD support 256, 64 (EHB), 32 or 16 colors and 1x1, 1x2, 2x1,
  41.         2x2,4x2,2x4 and 4x4 (look at the includes). It is also possible to choose the
  42.         FASTEST AVAILABLE, the BEST AVAILABLE mode or the mode that was selected from
  43.         the user as standard mode for his system, using the Screenmode Requester.
  44.  
  45.         If the user did not specify a standard c2p, this function will use the fastest
  46.         available mode.
  47.  
  48.         The signal indicates (for asynchrone c2p) that the c2p has done. For synchrone
  49.         ones it is set after quitting the function.
  50.  
  51.         In mode you specify which c2p mode to use.
  52.  
  53.         For Graphics Boards, ALWAYS 1x1 is used.
  54.  
  55.         IMPLEMENTED WITH SUBLIBRARIES WITH AT LEAST VERSION 2.0 (none up to now...)
  56.  
  57.    INPUTS
  58.         RtgScreen - The RtgScreen to use.
  59.         BufAdr - The address of the buffer to use
  60.         Array - The fastram buffer
  61.         Left - The x position on the Bitmap of RtgScreen where to put the stuff
  62.         Top - The y position
  63.         Width - The Width of the stuff
  64.         Height - The Height of the stuff
  65.  
  66.    SEE ALSO
  67.         CopyRtgPixelArray()
  68.  
  69. rtgmaster.library/CloseClient                               rtgmaster.library/CloseClient
  70.  
  71.    NAME
  72.         CloseClient -- Closes the Client of a TCP/IP connection again
  73.  
  74.    SYNOPSIS
  75.         CloseClient(SBase,Socket)
  76.                      A0    A1
  77.  
  78.         CloseClient(struct Library *,struct TCP_Socket *)
  79.  
  80.    FUNCTION
  81.         Terminates a "virtual connection" of TCP/IP and gives the Socket of the Client
  82.         back to the system. (For UDP it only gives the socket back to the system,
  83.         as there are no "virtual connections" in connectionless UDP).
  84.  
  85.         NOTE: It might appear strange to you, that you have to open bsdsocket.library
  86.         yourselves and provide it as parameter. This is needed because of some internal
  87.         problems of AmiTCP, that make it IMPOSSIBLE opening it inside a library. Look
  88.         at the Docs for more information.
  89.  
  90.         You do NOT have to use rtgmaster.library's Graphics Board features to
  91.         use rtgmaster.library's TCP/IP features, if you do not WANT to...
  92.  
  93.    INPUTS
  94.         SBase    - Result of the call (C Syntax here...)
  95.                    SBase = OpenLibrary("bsdsocket.library",0);
  96.         Socket   - The Socket of the Client you want to close.
  97.                    You should ONLY use this function for Clients,
  98.                    NOT FOR SERVERS !!!
  99.  
  100.  SEE ALSO
  101.         OpenClient(),OpenServer(),CloseServer(),RunServer(),RtgSend(),RtgRecv(),RtgAccept(),RtgIoctl(),GetUDPName(),RtgInAdr()
  102.  
  103. rtgmaster.library/CloseRtgScreen                            rtgmaster.library/CloseRtgScreen
  104.  
  105.    NAME
  106.         CloseRtgScreen -- Close a screen previously opened with
  107.                           OpenRtgScreen
  108.  
  109.    SYNOPSIS
  110.         CloseRtgScreen(RtgScreen)
  111.                         A0
  112.  
  113.         CloseRtgScreen(ULONG)
  114.  
  115.    FUNCTION
  116.         Should close a RtgScreen opened by this sublibrary and free all
  117.         of its resources.
  118.  
  119.    INPUTS
  120.         RtgScreen - A handle for a valid screen previously opened by
  121.                     this sublibrary's OpenRtgScreen() function.
  122.  
  123.    SEE ALSO
  124.         OpenRtgScreen()
  125.  
  126. rtgmaster.library/CloseServer                               rtgmaster.library/CloseServer
  127.  
  128.    NAME
  129.         CloseServer -- Closes the Server of a TCP/IP connection again
  130.  
  131.    SYNOPSIS
  132.         CloseServer(SBase,Socket)
  133.                      A0    A1
  134.  
  135.         CloseServer(struct Library *,struct TCP_Socket *)
  136.  
  137.    FUNCTION
  138.         Terminates a "virtual connection" of TCP/IP and gives the Socket of the Server
  139.         back to the system. For UDP it only gives the socket back to the system, as
  140.         for UDP there is no connection to terminate.
  141.  
  142.         NOTE: It might appear strange to you, that you have to open bsdsocket.library
  143.         yourselves and provide it as parameter. This is needed because of some internal
  144.         problems of AmiTCP, that make it IMPOSSIBLE opening it inside a library. Look
  145.         at the Docs for more information.
  146.  
  147.         You do NOT have to use rtgmaster.library's Graphics Board features to
  148.         use rtgmaster.library's TCP/IP features, if you do not WANT to...
  149.  
  150.    INPUTS
  151.         SBase    - Result of the call (C Syntax here...)
  152.                    SBase = OpenLibrary("bsdsocket.library",0);
  153.         Socket   - The Socket of the Client you want to close.
  154.                    You should ONLY use this function for Servers,
  155.                    NOT FOR CLIENTS !!!
  156.  
  157.  SEE ALSO
  158.         OpenClient(),OpenServer(),CloseClient(),RunServer(),RtgSend(),RtgRecv(),RtgAccept(),RtgIoctl(),GetUDPName(),RtgInAdr()
  159.  
  160. rtgmaster.library/CopyRtgPixelArray                      rtgmaster.library/CopyRtgPixelArray
  161.  
  162.    NAME
  163.         CopyRtgPixelArray -- Copy a rectangular array of pixels directly
  164.                              to the graphics card memory without any
  165.                              conversion
  166.  
  167.    SYNOPSIS
  168.         CopyRtgPixelArray(RtgScreen, BufferAdr, Array, Left, Top, Width, Height,SrcX,SrcY);
  169.                            A0         A1         A2     D0    D1   D2     D3     D4   D5
  170.  
  171.         CopyRtgPixelArray(struct RtgScreen *, APTR, APTR, ULONG, ULONG,
  172.                           ULONG, ULONG,ULONG,ULONG)
  173.  
  174.    FUNCTION
  175.         Copies a rectangular array of pixels directly to the graphics card
  176.         memory with no conversion.  The array of pixels is assumed to be
  177.         in the correct native format so it can be copied at maximum speed.
  178.         The copy routine however does take segment boundaries in account (if
  179.         required).
  180.  
  181.         This routine is mainly intended for machines which have relatively
  182.         fast FastRAM compared to the speed of the graphics card RAM.  This
  183.         is usually on machines with a 32-bit accelerator card which have
  184.         a Zorro-II graphics card installed.
  185.  
  186.         Note: For compatibility with rtgAMI.library,
  187.         Array should contain at least ((((width+15)>>4)<<4)*Height Bytes.
  188.  
  189.         NOT YET IMPLEMENTED ON ECS/AGA. SrcX and SrcY only implemented
  190.         for rtgEGS.library and rtgCGX.library up to now.
  191.  
  192.    INPUTS
  193.         RtgScreen - A handle for a valid screen previously opened by
  194.                     this sublibrary's OpenRtgScreen() function.
  195.         BufferAdr - The address of the memory containing the actual
  196.                     screen graphics
  197.         Array - Pointer to an array of pixels which is Width pixels wide,
  198.                 and Height pixels high.  The size of the pixel is dependant
  199.                 on the ScreenBuffer your copying to.  Make sure the array
  200.                 is in the correct native format.
  201.         Left - X position of the top-left of the rectangular pixel array
  202.         Top - Y position of the top-left of the rectangular pixel array
  203.         Width - Width of the array in pixels
  204.         Height - Height of the array in pixels
  205.  
  206.    SEE ALSO
  207.         OpenRtgScreen(), WritePixelArray(), WritePixelRGBArray()
  208.  
  209.  
  210. rtgmaster.library/DrawRtgLine                                   rtgmaster.library/DrawRtgLine
  211.  
  212.    NAME
  213.         DrawRtgLine - draws a line on a RtgScreen
  214.  
  215.    SYNOPSIS
  216.         DrawRtgLine(RtgScreen, BufferAdr, Color, X1, Y1, X2, Y2)
  217.                      A0         A1         D0     D1  D2  D3  D4
  218.  
  219.         DrawRtgLine(struct RtgScreen *, APTR, ULONG, LONG, LONG, LONG, LONG)
  220.  
  221.    FUNCTION
  222.         Draws a line on the screen which will be clipped if necessary.
  223.         NOTE : X1<=X2 AND Y1<=Y2 !!!
  224.         IMPLEMENTED WITH SUBLIBRARIES WITH AT LEAST VERSION 1.9
  225.  
  226.    INPUTS
  227.         RtgScreen - A handle for a valid screen previously opened by
  228.                     this sublibrary's OpenRtgScreen() function.
  229.         BufferAdr - The address of the memory containing the actual
  230.                     screen graphics
  231.         Color - Color number
  232.         X1,Y1,X2,Y2 - Draws a line from (X1,Y1) to (X2,Y2)
  233.  
  234.    SEE ALSO
  235.         OpenRtgScreen(), DrawRtgLineRGB()
  236.  
  237.  
  238. rtgmaster.library/DrawRtgLineRGB                             rtgmaster.library/DrawRtgLineRGB
  239.  
  240.    NAME
  241.         DrawRtgLineRGB - draws a line on a RtgScreen
  242.  
  243.    SYNOPSIS
  244.         DrawRtgLineRGB(RtgScreen, BufferAdr, Color, X1, Y1, X2, Y2)
  245.                         A0         A1         D0     D1  D2  D3  D4
  246.  
  247.         DrawRtgLineRGB(struct RtgScreen *, APTR, ULONG, LONG, LONG, LONG,
  248.                        LONG)
  249.  
  250.    FUNCTION
  251.         Draws a line on the screen which will be clipped if necessary.
  252.         NOTE: X1<=X2 AND Y1<=Y2 !!!
  253.  
  254.         IMPLEMENTED WITH SUBLIBRARIES WITH AT LEAST VERSION 1.9
  255.  
  256.    INPUTS
  257.         RtgScreen - A handle for a valid screen previously opened by
  258.                     this sublibrary's OpenRtgScreen() function.
  259.         BufferAdr - The address of the memory containing the actual
  260.                     screen graphics
  261.         Color - A 32-bit value describing the color
  262.         X1,Y1,X2,Y2 - Draws a line from (X1,Y1) to (X2,Y2)
  263.  
  264.    SEE ALSO
  265.         OpenRtgScreen(), DrawRtgLine()
  266.  
  267.  
  268. rtgmaster.library/FillRtgRect                                   rtgmaster.library/FillRtgRect
  269.  
  270.    NAME
  271.         FillRtgRect - draws a filled rectangle to a RtgScreen
  272.  
  273.    SYNOPSIS
  274.         FillRtgRect(RtgScreen, BufferAdr, Color, Left, Top, Width, Height)
  275.                      A0         A1         D0     D1    D2   D3     D4
  276.  
  277.         FillRtgRect(struct RtgScreen *, APTR, ULONG, ULONG, ULONG,
  278.                     ULONG, ULONG)
  279.  
  280.    FUNCTION
  281.         Draws a filled rectangle at the specified position on a RtgScreen.
  282.         The BufferAdr is the starting address of the buffer the users wants
  283.         to draw the rectangle in.  The user has obtained this address using
  284.         LockRtgScreen() and GetBufAdr().  The BufferAdr is needed to specify
  285.         the correct buffer for screens which are double or triple buffered.
  286.  
  287.         This function should only work for Palette mapped modes, Color is
  288.         the Color number of the palette.
  289.  
  290.         IMPLEMENTED WITH SUBLIBRARIES WITH AT LEAST VERSION 1.9
  291.  
  292.    INPUTS
  293.         RtgScreen - A handle for a valid screen previously opened by
  294.                     this sublibrary's OpenRtgScreen() function.
  295.         BufferAdr - The address of the memory containing the actual
  296.                     screen graphics
  297.         Color - Color number
  298.         Left - X position of the top-left of the rectangle
  299.         Top - Y position of the top-left of the rectangle
  300.         Width - Width of the rectangle in pixels
  301.         Height - Height of the rectangle in pixels
  302.  
  303.    SEE ALSO
  304.         OpenRtgScreen(), FillRtgRectRGB()
  305.  
  306.  
  307.  
  308. rtgmaster.library/FillRtgRectRGB                             rtgmaster.library/FillRtgRectRGB
  309.  
  310.    NAME
  311.         FillRtgRectRGB - draws a filled rectangle to a RtgScreen
  312.  
  313.    SYNOPSIS
  314.         FillRtgRectRGB(RtgScreen, BufferAdr, Color, Left, Top, Width, Height)
  315.                         A0         A1         D0     D1    D2   D3     D4
  316.  
  317.         FillRtgRectRGB(struct RtgScreen *, APTR, ULONG, ULONG, ULONG,
  318.                        ULONG, ULONG)
  319.  
  320.    FUNCTION
  321.         Draws a filled rectangle at the specified position on a RtgScreen.
  322.         The BufferAdr is the starting address of the buffer the users wants
  323.         to draw the rectangle in.  The user has obtained this address using
  324.         LockRtgScreen() and GetBufAdr().  The BufferAdr is needed to specify
  325.         the correct buffer for screens which are double or triple buffered.
  326.  
  327.         This function should only work for True Color modes, Color is
  328.         a 32 bit value which specifies what Color the pixel should be.
  329.         The layout of this 32-bit value is as follows:
  330.  
  331.         %aaaaaaaa.rrrrrrrr.gggggggg.bbbbbbbb
  332.  
  333.         a = AlphaChannel (8-bits) which may or may not be ignored.  The
  334.             user will set this to zero if the user doesn't want to use
  335.             AlphaChannel.
  336.         r = Red component (8-bits) of the 24-bit RGB value
  337.         g = Green component (8-bits) of the 24-bit RGB value
  338.         b = Blue component (8-bits) of the 24-bit RGB value
  339.  
  340.         IMPLEMENTED WITH SUBLIBRARIES WITH AT LEAST VERSION 1.9
  341.  
  342.    INPUTS
  343.         RtgScreen - A handle for a valid screen previously opened by
  344.                     this sublibrary's OpenRtgScreen() function.
  345.         BufferAdr - The address of the memory containing the actual
  346.                     screen graphics
  347.         Color - A 32-bit value describing the color (see above)
  348.         Left - X position of the top-left of the rectangle
  349.         Top - Y position of the top-left of the rectangle
  350.         Width - Width of the rectangle in pixels
  351.         Height - Height of the rectangle in pixels
  352.  
  353.    SEE ALSO
  354.         OpenRtgScreen(), FillRtgRect()
  355.  
  356. rtgmaster.library/RtgScreenModeReq                          rtgmaster.library/FreeRtgScreenModeReq
  357.  
  358.    NAME
  359.         FreeRtgScreenModeReq - frees the ScreenReq structure again
  360.  
  361.    SYNOPSIS
  362.         FreeRtgScreenModeReq(myreq)
  363.                               A0
  364.  
  365.         FreeRtgScreenModeReq(struct ScreenReq *)
  366.  
  367.    FUNCTION
  368.         This function frees the memory allocated by RtgScreenModeReq again.
  369.         Should be called after you need that data not any longer. Note: This
  370.         function caused a system crash with an early Beta Version of rtgmaster.library.
  371.         This does no longer happen, as this bug got fixed. This function is
  372.         only in the master-library, not in the sublibraries.
  373.  
  374.    INPUTS
  375.         myreq - The ScreenReq Structure returned by RtgScreenModeReq
  376.  
  377.    SEE ALSO
  378.         RtgScreenModeReq()
  379.  
  380. rtgmaster.library/FreeScreenModes                           rtgmaster.library/FreeScreenModes
  381.  
  382.    NAME
  383.         FreeScreenModes - frees a list of screenmodes
  384.  
  385.    SYNOPSIS
  386.         FreeScreenModes(array of screenmodes)
  387.                          A0
  388.  
  389.         FreeScreenModes(APTR)
  390.  
  391.    FUNCTION
  392.         This function should free a previously with GetScreenModes()
  393.         allocated list of ScreenMode structures, including everything else
  394.         GetScreenModes() allocated.  Be prepared to handle a NULL pointer.
  395.         THIS FUNCTION IS ONLY IN SUBLIBRARIES, NOT IN THE MASTER-LIBRARY
  396.         ITSELF. IT IS ONLY CALLED BY RTGMASTER.LIBRARY ITSELF.
  397.  
  398.    INPUTS
  399.         array - an array of ScreenMode structures or NULL
  400.  
  401.    SEE ALSO
  402.         GetScreenModes()
  403.  
  404.  
  405.  
  406. rtgmaster.library/GetBufAdr                                       rtgmaster.library/GetBufAdr
  407.  
  408.    NAME
  409.         GetBufAdr -- Get the address for one of the buffers from a
  410.                      multi-buffered RtgScreen
  411.  
  412.    SYNOPSIS
  413.         address = GetBufAdr(RtgScreen, Buffer)
  414.          D0                  A0         D0
  415.  
  416.         APTR GetBufAdr(ULONG, ULONG)
  417.  
  418.    FUNCTION
  419.         If the user is using multi-buffered screens, it might be usefull
  420.         to know where the two buffers start in memory.  After a
  421.         LockRtgScreen() the user can call this function with a RtgScreen
  422.         handle and a number to get the address of the corresponding
  423.         buffer.
  424.  
  425.         The address is only valid if the RtgScreen is currently locked
  426.         using LockRtgScreen().
  427.  
  428.    INPUTS
  429.         RtgScreen - A handle for a valid screen previously opened by
  430.                     this sublibrary's OpenRtgScreen() function.
  431.         Buffer - The buffer number the user wants the address of
  432.  
  433.    RESULTS
  434.         address - the address of the buffer, or NULL for failure
  435.  
  436.    SEE ALSO
  437.         LockRtgScreen(), OpenRtgScreen()
  438.  
  439.  
  440. rtgmaster.library/GetRtgScreenData                        rtgmaster.library/GetRtgScreenData
  441.  
  442.    NAME
  443.         GetRtgScreenData -- Fills a TagList with data about the RtgScreen 
  444.  
  445.    SYNOPSIS
  446.         GetRtgScreenData(RtgScreen, TagList)
  447.                           A0         A1
  448.  
  449.         GetRtgScreenData(ULONG, struct TagItem *)
  450.  
  451.    FUNCTION
  452.         This function should fill the TI_DATA fields of the passed in
  453.         TagList with the requested information.
  454.  
  455.         See for available tags and descriptions in the .i/.h file.
  456.  
  457.         NOTE: Starting with sublibrary V2.2, this function can also
  458.         be used to find out to what BUSSYSTEM a Graphics Board is
  459.         connected. In the original design of rtgmaster an extra function
  460.         was intended for that, but now it is the job of GetRtgScreenData.
  461.  
  462.    INPUTS
  463.         RtgScreen - A handle for a valid screen previously opened by
  464.                     this sublibrary's OpenRtgScreen() function.
  465.         TagList - TagList which should be filled in with requested info.
  466.  
  467.    SEE ALSO
  468.         OpenRtgScreen(), GetBufAdr()
  469.  
  470.  
  471.  
  472. rtgmaster.library/GetScreenModes                             rtgmaster.library/GetScreenModes
  473.  
  474.    NAME
  475.         GetScreenModes - builds a list of available screenmodes
  476.  
  477.    SYNOPSIS
  478.         array of ScreenMode structures = GetScreenModes()
  479.          D0
  480.  
  481.         APTR GetScreenModes()
  482.  
  483.    FUNCTION
  484.         This function should return a linked list of ScreenMode structures
  485.         describing all the available ScreenModes available to this
  486.         sublibrary.  If there aren't any, or you couldn't allocate the
  487.         memory for the list then return 0. THIS FUNCTION IS ONLY IN SUBLIBRARIES,
  488.         NOT IN THE MASTER-LIBRARY ITSELF. IT IS ONLY CALLED BY RTGMASTER.LIBRARY
  489.         ITSELF.
  490.  
  491.    RESULTS
  492.         array - an array of ScreenMode structures or NULL
  493.  
  494.    SEE ALSO
  495.         FreeScreenModes()
  496.  
  497.  
  498.  
  499. rtgmaster.library/GetSegment                                     rtgmaster.library/GetSegment
  500.  
  501.    NAME
  502.         GetSegment - get the active segment or ~0
  503.  
  504.    SYNOPSIS
  505.         segnum = GetSegment()
  506.          D0
  507.  
  508.         ULONG GetSegment()
  509.  
  510.    FUNCTION
  511.         If the graphic board works in segment mode -- with a
  512.         memory window of 64 KByte -- you will get the number of the
  513.         active segment after calling this function.
  514.  
  515.         If the graphic board works non segmented, you will get
  516.         ~0 (= 0xFFFFFFFF) as a result to this call.
  517.  
  518.    RESULTS
  519.         segnum - number of active segment, or -1 if the board works
  520.                  non-segmented
  521.  
  522.    SEE ALSO
  523.         SetSegment()
  524.  
  525.  
  526. rtgmaster.library/GetUDPName                                     rtgmaster.library/GetUDPName
  527.  
  528.    NAME
  529.         GetUDPName - Get the sockaddr_in structure of a UDP Client/Server
  530.  
  531.    SYNOPSIS
  532.         name = GetUDPName(SocketBase, sock)
  533.                     A0          A1
  534.  
  535.         struct sockaddr_in *GetUDPName(struct Library *, struct RTG_Socket *)
  536.  
  537.    FUNCTION
  538.         If this is UDP, you will get the sockaddr_in structure of a Client/Server,
  539.         else you will get 0. For what this is intended, read RtgRecv/RtgSend/RtgInAdr.
  540.         And of course the Docs of rtgmaster.library where detailed information about
  541.         TCP, IP and UDP is found.
  542.  
  543.         NOTE: It might appear strange to you, that you have to open bsdsocket.library
  544.         yourselves and provide it as parameter. This is needed because of some internal
  545.         problems of AmiTCP, that make it IMPOSSIBLE opening it inside a library. Look
  546.         at the Docs for more information.
  547.  
  548.         You do NOT have to use rtgmaster.library's Graphics Board features to
  549.         use rtgmaster.library's TCP/IP features, if you do not WANT to...
  550.  
  551.    INPUTS
  552.         SBase    - Result of the call (C Syntax here...)
  553.                    SBase = OpenLibrary("bsdsocket.library",0);
  554.         Socket   - The Socket of the Client you want to close.
  555.                    You should ONLY use this function for Clients,
  556.                    NOT FOR SERVERS !!!
  557.  
  558.    RESULTS
  559.         name     - The sockaddr_in structure of the Client/Server
  560.  
  561.  SEE ALSO
  562.         OpenClient(),OpenServer(),CloseServer(),RunServer(),RtgSend(),RtgRecv(),RtgAccept(),RtgIoctl(),RtgInAdr()
  563.  
  564. rtgmaster.library/LoadRGBRtg                                     rtgmaster.library/LoadRGBRtg
  565.  
  566.    NAME
  567.         LoadRGBRtg - changes one or more colors of a RtgScreen
  568.  
  569.    SYNOPSIS
  570.         LoadRGBRtg(RtgScreen, Table)
  571.                     A0         A1
  572.  
  573.         LoadRGBRtg(ULONG, APTR)
  574.  
  575.    FUNCTION
  576.         Enables the user to change one or more colors of his/her screen.
  577.         This function only works for RtgScreens which have a palette, and
  578.         thus won't work for the True-color modes.
  579.  
  580.    INPUTS
  581.         RtgScreen - A handle for a valid screen previously opened by
  582.                     this sublibrary's OpenRtgScreen() function.
  583.         Table - A pointer to a series of records which describe which
  584.                 colors to modify
  585.  
  586.    NOTES
  587.         Passing a NULL Table must be ignored.  The format of the Table
  588.         passed is a series of records, each with the this format:
  589.  
  590.            WORD  Count value: Number of colors to load
  591.            WORD  Number of first color to be loaded
  592.  
  593.         After these two words, a list of 3 Longs follow as many times
  594.         as specified by the first word.  These 3 longwords represent the
  595.         left justified 32 bit RGB value.
  596.  
  597.         And then the list repeats until ended with a count value of 0.
  598.  
  599.         See for more information about the table graphics/LoadRGB32.
  600.         This function must use the same format.
  601.  
  602.    SEE ALSO
  603.         OpenRtgScreen(), graphics/LoadRGB32()
  604.  
  605.  
  606.  
  607. rtgmaster.library/LockRtgScreen                              rtgmaster.library/LockRtgScreen
  608.  
  609.    NAME
  610.         LockRtgScreen -- Locks a RtgScreen (prevents it from being moved
  611.                          in memory)
  612.  
  613.    SYNOPSIS
  614.         address = LockRtgScreen(RtgScreen)
  615.          D0                      A0
  616.  
  617.         APTR LockRtgScreen(ULONG)
  618.  
  619.    FUNCTION
  620.         This function should make sure that the screen is not moved from
  621.         it's current location in memory.  In other words, it will guarantee
  622.         that the address you get back from this function remains valid
  623.         until you call UnlockRtgScreen().
  624.     
  625.         The result from this function should be the address of the buffer
  626.         associated with the screen either in the graphics cards own
  627.         memory or the computers memory.
  628.  
  629.         For multi-buffered screens the return-address must point to buffer
  630.         0 for this RtgScreen.  To get the addresses of the other
  631.         buffers the user will use GetBufAdr().
  632.  
  633.         LockRtgScreen and UnlockRtgScreen functions must nest, which means
  634.         you must call an UnlockRtgScreen for every LockRtgScreen.  The
  635.         field rs_Locks in the RtgScreen structure should be used to keep
  636.         track of the number of times a screen was locked.
  637.  
  638.         Note : On some Graphics Boards this function will take some
  639.         CPU time to happen, so it is advised ONLY to call it *once* at the start
  640.         of your code (And UnlockRtgScreen *once* at the end of your code,
  641.         to be on the sure side...)
  642.  
  643.    INPUTS
  644.         RtgScreen - A handle for a valid screen previously opened by
  645.                     this sublibrary's OpenRtgScreen() function.
  646.  
  647.    RESULTS
  648.         address - The address of the (first) buffer of this screen.
  649.  
  650.    SEE ALSO
  651.         UnlockRtgScreen(), OpenRtgScreen(), GetBufAdr()
  652.  
  653. rtgmaster.library/OpenClient                                 rtgmaster.library/OpenClient
  654.  
  655.    NAME
  656.         OpenClient    -- Open a TCP/IP Client
  657.  
  658.    SYNOPSIS
  659.         Socket = OpenClient(SBase,host,port,mode,protocol)
  660.          D0                  A0    A1   D0   D1   D2
  661.  
  662.         struct RTG_Socket *OpenClient(struct Library *,char *,int,int,int)
  663.  
  664.    FUNCTION
  665.         For TCP, this function opens a "virtual connection" between two applications.
  666.         For UDP it creates a socket that can be used by the application to
  667.         transfer data connectionless to other applications.
  668.         This function is the "Client part" of the connection. The protocol
  669.         being used is TCP/IP.
  670.  
  671.         For more information, look at the docs. There is a chapter about
  672.         "TCP/IP programming for newcomers", that shows you, how to support
  673.         netework gaming for your computer game, even if you never heard of
  674.         TCP/IP before :) Up to now rtgmaster.library only supports the
  675.         "protocol stack" AmiTCP, no AS225 support up to now.  Runs for sure
  676.         with AmiTCP 4.0 demo from Aminet, i do not know about earlier versions.
  677.  
  678.         NOTE: It might appear strange to you, that you have to open bsdsocket.library
  679.         yourselves and provide it as parameter. This is needed because of some internal
  680.         problems of AmiTCP, that make it IMPOSSIBLE opening it inside a library. Look
  681.         at the Docs for more information.
  682.  
  683.         You do NOT have to use rtgmaster.library's Graphics Board features to
  684.         use rtgmaster.library's TCP/IP features, if you do not WANT to...
  685.  
  686.    INPUTS
  687.         SBase    - Result of the call (C Syntax here...)
  688.                    SBase = OpenLibrary("bsdsocket.library",0);
  689.         host     - hostname of the "Server",  to which you want to connect your
  690.                    application (for example "194.55.101.26").
  691.         port     - The port your application uses. For example 4000.
  692.                    Be sure to use a number bigger than 3000, small numbers
  693.                    are often used for different protocols in TCP/IP. For example
  694.                    21 is telnet.
  695.         mode     - The mode of the connection. Up to now only SOCK_STREAM is
  696.                    supported ("virtual connection using a datastream").
  697.                    SOCK_DGRAM probably will give you a UDP connection, but
  698.                    i do not know enough about UDP to make this really working...
  699.                    maybe in a future version...
  700.         protocol - The protocol To be used. Set this to 0 currently.
  701.                    mode SOCK_STREAM and protocol 0 will result in a TCP connection.
  702.  
  703.  
  704.    RESULTS
  705.         Socket   - The "Socket" of the Application. See more in the docs.
  706.  
  707.    SEE ALSO
  708.         OpenServer(),CloseClient(),CloseServer(),RunServer(),RtgSend(),RtgRecv(),RtgAccept(),RtgIoctl(),GetUDPName(),RtgInAdr()
  709.  
  710. rtgmaster.library/OpenRtgScreen                              rtgmaster.library/OpenRtgScreen
  711.  
  712.    NAME
  713.         OpenRtgScreen -- Open a screen
  714.  
  715.    SYNOPSIS
  716.         RtgScreen = OpenRtgScreen(ScreenReq, RtgTags)
  717.          D0                        A0         A1
  718.  
  719.         struct RtgScreen *OpenRtgScreen(struct ScreenReq *, struct TagItem *)
  720.  
  721.  
  722.    FUNCTION
  723.         This function should open the screen which falls within the 
  724.         parameters specified by the user.  If this function can't
  725.         deliver such a screen than it will fail and will return zero.
  726.  
  727.         Note that the Width and Height values you get from
  728.         rtgmaster.library have been checked to see if they are valid
  729.         for this screenmode.  Also note that RtgTags may be zero.
  730.  
  731.    INPUTS
  732.         RtgTags - Pointer to (an array of) TagItem structures,
  733.                   terminated by the value TAG_END (0).
  734.         ScreenReq - ScreenReq structure as returned by RtgScreenModeReq()
  735.                     of rtgmaster.library, see rtg.i for more information
  736.  
  737.         Each TagItem is an optional tagged data structure which
  738.         identifies a parameter to OpenRtgScreen().  The applicable tag ID
  739.         values for TagItem.ti_Tag and their corresponding data can be
  740.         found in the .i/.h file where the Tags for OpenRtgScreen() are
  741.         specified.
  742.  
  743.    RESULTS
  744.         RtgScreen - A handle for the screen you opened.  The user may
  745.                     later use this handle to get information about
  746.                     this screen or perform actions like setting the 
  747.                     palette or double/triple buffering.  You should
  748.                     returns NULL if the screen couldn't be opened.
  749.  
  750.    SEE ALSO
  751.         CloseRtgScreen()
  752.  
  753. rtgmaster.library/OpenServer                               rtgmaster.library/OpenServer
  754.  
  755.    NAME
  756.         OpenServer - Opens a TCP/IP Server
  757.  
  758.    SYNOPSIS
  759.         Socket=OpenServer(SBase,port,mode,protocol)
  760.          D0                A0    D0   D1   D2
  761.  
  762.         struct TCP_Connect *OpenServer(struct Library *,int,int,int)
  763.  
  764.    FUNCTION
  765.         For TCP this function opens a "virtual connection" between two applications.
  766.         For UDP it creates a server that UDP clients can access.
  767.  
  768.         This function is the "Server part" of the connection. The protocol
  769.         being used is TCP/IP. Up to now, as to the "transport protocol", only
  770.         TCP is supported, no UDP (maybe in a future version ???)
  771.         For more information, look at the docs. There is a chapter about
  772.         "TCP/IP programming for newcomers", that shows you, how to support
  773.         netework gaming for your computer game, even if you never heard of
  774.         TCP/IP before :) Up to now rtgmaster.library only supports the
  775.         "protocol stack" AmiTCP, no AS225 support up to now.  Runs for sure
  776.         with AmiTCP 4.0 demo from Aminet, i do not know about earlier versions.
  777.  
  778.         NOTE: It might appear strange to you, that you have to open bsdsocket.library
  779.         yourselves and provide it as parameter. This is needed because of some internal
  780.         problems of AmiTCP, that make it IMPOSSIBLE opening it inside a library. Look
  781.         at the Docs for more information.
  782.  
  783.         You do NOT have to use rtgmaster.library's Graphics Board features to
  784.         use rtgmaster.library's TCP/IP features, if you do not WANT to...
  785.  
  786.    INPUTS
  787.         SBase    - Result of the call (C Syntax here...)
  788.                    SBase = OpenLibrary("bsdsocket.library",0);
  789.         port     - The port your application uses. For example 4000.
  790.                    Be sure to use a number bigger than 3000, small numbers
  791.                    are often used for different protocols in TCP/IP. For example
  792.                    21 is telnet.
  793.         mode     - The mode of the connection. Up to now only SOCK_STREAM is
  794.                    supported ("virtual connection using a datastream").
  795.                    SOCK_DGRAM probably will give you a UDP connection, but
  796.                    i do not know enough about UDP to make this really working...
  797.                    maybe in a future version...
  798.         protocol - The protocol To be used. Set this to 0 currently.
  799.                    mode SOCK_STREAM and protocol 0 will result in a TCP connection.
  800.  
  801.    RESULTS
  802.         Socket   - The "Socket" of the Application. See more in the docs.
  803.  
  804.  SEE ALSO
  805.         OpenClient(),CloseClient(),CloseServer(),RunServer(),RtgSend(),RtgRecv(),RtgAccept(),RtgIoctl(),GetUDPName(),RtgInAdr()
  806.  
  807. rtgmaster.library/RtgAccept                                rtgmaster.library/RtgAccept
  808.  
  809.    NAME
  810.         RtgAccept - Let the server accept a connection deminded by a Client
  811.  
  812.    SYNOPSIS
  813.         Socket=RtgAccept(SBase,Socket)
  814.          D0               A0    A1
  815.  
  816.         struct RTG_Socket *RtgAccept(struct Library *,struct RTG_Socket *)
  817.  
  818.    FUNCTION
  819.         if you do not use the RunServer function (you do not use it, if you only
  820.         do a point-to-point connection), you have to do this call on Server side
  821.         to wait for the Client to connect. If you use RunSercer, DO NOT USE IT. It
  822.         is only for connecting exactly TWO systems (one being  the server, one the
  823.         client), not for connecting ONE server with SEVERAL clients...
  824.  
  825.         Also do not use it for UDP connection. RtgAccept is only needed for TCP.
  826.         It does not work with UDP.
  827.  
  828.         NOTE: It might appear strange to you, that you have to open bsdsocket.library
  829.         yourselves and provide it as parameter. This is needed because of some internal
  830.         problems of AmiTCP, that make it IMPOSSIBLE opening it inside a library. Look
  831.         at the Docs for more information.
  832.  
  833.         You do NOT have to use rtgmaster.library's Graphics Board features to
  834.         use rtgmaster.library's TCP/IP features, if you do not WANT to...
  835.  
  836.  
  837.    INPUTS
  838.         SBase    - Result of the call (C Syntax here...)
  839.                    SBase = OpenLibrary("bsdsocket.library",0);
  840.         Socket   - the Socket of the Server
  841.  
  842.     RESULTS
  843.         Socket   - The "Socket" of the Client, that connected. See more in the docs.
  844.  
  845.     SEE ALSO
  846.         OpenClient(),CloseClient(),CloseClient(),CloseServer(),RunServer(),RtgSend(),RtgRecv(),RtgIoctl(),GetUDPName(),RtgInAdr()
  847.  
  848. rtgmaster.library/RtgBlit                                  rtgmaster.library/RtgBlit
  849.  
  850.    NAME
  851.         RtgBlit - Performs a Blit without waiting
  852.  
  853.    SYNOPSIS
  854.         RtgBlit(RtgScreen,SrcBuf,DstBuf,SrcX,SrcY,DstX,DstY,Width,Height,Minterm)
  855.                  A0        a1     a2     d0   d1   d2   d3   d4    d5     d6
  856.  
  857.         void RtgBlit(struct RtgScreen *, ULONG, ULONG, ULONG, ULONG, ULONG, ULONG, ULONG, ULONG,UBYTE)
  858.  
  859.    FUNCTION
  860.         This function blits the rectangle at (SrxX,SrcY) in the Buffer with the
  861.         NUMBER SrcBuf (0-2) to the position (DstX,DstY) in the Buffer with the
  862.         NUMBER DstBuf (0-2). The Blit has Width Width and Height Height.
  863.  
  864.         For most GFX Boards this function is the fastest way to move
  865.         graphics data.
  866.  
  867.         Note : On some boards (for example EGS Boards) this function might
  868.         wait on the Blitter to be finished as this can't be done in an
  869.         other way with these boards. For these boards WaitRtgBlit simply
  870.         does nothing.
  871.  
  872.         Note : The source and the destination rectangle should NOT OVERLAP !!!
  873.  
  874.         Valid minterms : $30,$50,$60,$80, $C0. NO OTHER MINTERMS ARE VALID.
  875.         OTHER MINTERMS MIGHT WORK WITH SOME SUBLIBRARIES, BUT PROBABLY NOT WITH
  876.         ALL SUBLIBRARIES.
  877.  
  878.         Note: This function MIGHT or MIGHT NOT work with some of the Minterms
  879.         on rtgEGS.library... at least for $C0 it works for all... for the rest...
  880.         i do not see myself as Betatester of half-finished WB-Emulations...
  881.  
  882.         THIS FUNCTION IS IMPLEMENTED IN SUBLIBRARIES STARTING WITH VERSION 1.8
  883.  
  884.    INPUTS
  885.         RtgScreen - The RtgScreen where the Blit should happen
  886.         SrcBuf - The Buffer NUMBER (not address !!!) of the Source Buffer
  887.         DstBuf - The Buffer NUMBER (not address !!!) of the Destination Buffer
  888.         SrcX - The X coordinate of the source Rectangle
  889.         SrcY - The Y coordinate of the source Rectangle
  890.         DstX - The X coordinate of the Destination Rectangle
  891.         DstY - The Y coordinate of the Destination Rectangle
  892.         Width - The Width of the Blit
  893.         Height - The Height of the Blit
  894.         minterm - the minterm of the Blit, defined as usual
  895.  
  896.    SEE ALSO
  897.         OpenRtgScreen(), WaitRtgBlit(), SwitchScreens()
  898.  
  899. rtgmaster.library/RtgBltClear                              rtgmaster.library/BltClear
  900.  
  901.    SYNOPSIS
  902.         RtgBltClear(RtgScreen,BufNum,xpos,ypos,width,height)
  903.  
  904.         RtgBltClear(struct RtgScreen *,ULONG,ULONG,ULONG,ULONG,ULONG)
  905.  
  906.    FUNCTION
  907.         This function clears a rectangular area using the GFX Board
  908.         blitter. For people who wonder, why i did not implement that
  909.         the "usual" way, like done in graphics.library : The graphics.library
  910.         function would not be possible under EGS, therefor i did it
  911.         this way. The function usually does not wait for the Blitter,
  912.         use WaitRtgBlit for this (unless under EGS... like explained
  913.         in RtgBlit and WaitRtgBlit...)
  914.  
  915.         THIS FUNCTION IS IMPLEMENTED WITH SUBLIBRARIES STARTING WITH VERSION 1.8
  916.  
  917.    INPUTS
  918.         RtgScreen - The RtgScreen
  919.         BufNum - The NUMBER of the concerned Buffer, between 0 and 2 (NOT the buffer address !!!)
  920.         xpos - the start x position of the rectangle to be cleared
  921.         ypos - the start y position of the rectangle to be cleared
  922.         width - the width of the rectangle
  923.         height - the height of the rectangle
  924.  
  925.    SEE ALSO
  926.         RtgBlit(),WaitRtgBlit()
  927.  
  928.  
  929. rtgmaster.library/RtgClearPointer                           rtgmaster.library/RtgClearPointer
  930.  
  931.    NAME
  932.         RtgClearPointer - resets the pointer to its default image
  933.  
  934.    SYNOPSIS
  935.         RtgClearPointer(RtgScreen)
  936.                          A0
  937.  
  938.         void RtgClearPointer(struct RtgScreen *)
  939.  
  940.    FUNCTION
  941.         This restores the default image of the mousepointer. This is
  942.         very useful, if you changed it with RtgSetPointer, but sometimes
  943.         want the default pointer image, too. The pointer is only changed
  944.         on THIS RtgScreen.
  945.  
  946.    INPUTS
  947.         RtgScreen - The RtgScreen, which pointer should be resetted...
  948.  
  949.    NOTES
  950.        Not implemented yet on rtgPICA.library and rtgEGS.library
  951.  
  952.    SEE ALSO
  953.        RtgSetPointer()
  954.  
  955. rtgmaster.library/RtgCloseFont                              rtgmaster.library/RtgCloseFont
  956.  
  957.    NAME
  958.         RtgCloseFont - closes an AmigaFont
  959.  
  960.    SYNOPSIS
  961.         RtgCloseFont(RtgScreen,font)
  962.                       A0        A1
  963.  
  964.         void RtgCloseFont(struct RtgScreen *,void *)
  965.  
  966.    FUNCTION
  967.         This function closes an AmigaFont on
  968.         a RtgScreen, much the same way, like OpenDiskFont does for
  969.         Intuition Screens. The font parameter of the call
  970.         is not for all WB Emulations a TextFont pointer. Don't use
  971.         CloseFont with rtgmaster.library, use
  972.         RtgCloseFont, for the best possible compatibility with
  973.         all Sublibraries !!!
  974.  
  975.    INPUTS
  976.         RtgScreen - an RtgScreen
  977.         font      - a Font pointer. the structure of it is PRIVATE
  978.                     to rtgmaster.library (and not the same for all
  979.                     sublibraries...)
  980.  
  981.    NOTES
  982.         Not yet implemented for rtgPICA.library
  983.  
  984.    SEE ALSO
  985.         RtgOpenFont(),RtgSetFont(),RtgSetTextMode(),RtgText(),RtgSetTextModeRGB
  986.  
  987.  
  988. rtgmaster.library/RtgInAdr                                 rtgmaster.library/RtgInAdr
  989.  
  990.    NAME
  991.         RtgInAdr - Find out the IP Address of a Receiver/Sender
  992.  
  993.    SYNOPSIS
  994.         ip = RtgInAdr(SBase,si)
  995.         D0             A0   A1
  996.  
  997.         char *RtgInAdr(struct Library *,struct sockaddr_in *)
  998.  
  999.    FUNCTION
  1000.         This function finds out the IP Address of a Receiver/Sender.
  1001.         You get back the sockaddr_in structure of a receiver/sender by
  1002.         RtgRecv/RtgSend or by using GetUDPName. This function ONLY
  1003.         works for UDP, not for TCP !!! It is used to differentiate
  1004.         Clients running on different machines from each other, if
  1005.         one does a Multiple Client "connection" (should not be called
  1006.         like that, as UDP is connectionless, but do you know a better
  1007.         term ?), without using RunServer...
  1008.  
  1009.         Of course this function can't differentiate multiple Clients
  1010.         running on the same machine...
  1011.  
  1012.         NOTE: It might appear strange to you, that you have to open bsdsocket.library
  1013.         yourselves and provide it as parameter. This is needed because of some internal
  1014.         problems of AmiTCP, that make it IMPOSSIBLE opening it inside a library. Look
  1015.         at the Docs for more information.
  1016.  
  1017.         You do NOT have to use rtgmaster.library's Graphics Board features to
  1018.         use rtgmaster.library's TCP/IP features, if you do not WANT to...
  1019.  
  1020.    INPUTS
  1021.           SBase    - Result of the call (C Syntax here...)
  1022.                      SBase = OpenLibrary("bsdsocket.library",0);
  1023.           si       - Special structure returned by above mentioned calls
  1024.  
  1025.    RESULTS
  1026.           ip       - IP Address as string (for example "194.55.101.26")
  1027.  
  1028.    SEE ALSO
  1029.         OpenClient(),OpenServer(),CloseClient(),CloseClient(),CloseServer(),RunServer(),RtgSend(),RtgAccept(),GetUDPName()
  1030.  
  1031. rtgmaster.library/RtgInitRDCMP                             rtgmaster.library/RtgInitRDCMP
  1032.  
  1033.    NAME
  1034.         RtgInitRDCMP - Inits the rtgmaster direct communication message port (RDCMP)
  1035.  
  1036.    SYNOPSIS
  1037.         result = RtgInitRDCMP(RtgScreen)
  1038.          d0                   a0
  1039.  
  1040.         void *RtgInitRDCMP(struct RtgScreen *)
  1041.  
  1042.    FUNCTION
  1043.         Inits the input port of rtgmaster. Returns 0, if initialization failed (for example,
  1044.         if sublibrary does not support RDCMP), something >0 else. The port has to be initialized
  1045.         once after Screen-Opening.
  1046.  
  1047.    INPUTS
  1048.         RtgScreen - The Screen, which port is to init
  1049.  
  1050.    RESULTS
  1051.         result - 0, if failed, something else, if succeeded
  1052.  
  1053.    NOTES
  1054.        DOES NOT RUN ON rtgPICA.library up to now !!!
  1055.        RDCMP supports both waiting and polling !!!
  1056.        As to my experiences, better use RDCMP than anything else...
  1057.        other methods i tried tended to lose mouseclicks, if
  1058.        they came very fast, and if the application took a lot
  1059.        of processing time. RDCMP does not lose data.
  1060.  
  1061.    SEE ALSO
  1062.         RtgWaitRDCMP(),RtgGetMsg(),RtgReplyMsg()
  1063.  
  1064. rtgmaster.library/RtgIoctl                                 rtgmaster.library/RtgIoctl
  1065.  
  1066.    NAME
  1067.         RtgIoctl - Set a Socket to "Blocking" or to "Non-Blocking" mode
  1068.  
  1069.    SYNOPSIS
  1070.         result = RtgIoctl(SBase,Socket,arg)
  1071.          D0                A0    A1     A2
  1072.  
  1073.         int RtgIoctl(struct Library *,struct RTG_Socket *,long *)
  1074.  
  1075.    FUNCTION
  1076.         This function determins, if RtgRecv and RtgSend will WAIT will the data
  1077.         was transmitted, or if they fail, if the data currently could not be
  1078.         transmitted. If arg POINTS to the VALUE 1, we have "non-blocking" (it does
  1079.         not wait), if it POINTS to 0, we have "blocking" (it waits). Default (if
  1080.         you do not call RtgIoctl at all) is "blocking".
  1081.  
  1082.         NOTE: It might appear strange to you, that you have to open bsdsocket.library
  1083.         yourselves and provide it as parameter. This is needed because of some internal
  1084.         problems of AmiTCP, that make it IMPOSSIBLE opening it inside a library. Look
  1085.         at the Docs for more information.
  1086.  
  1087.         You do NOT have to use rtgmaster.library's Graphics Board features to
  1088.         use rtgmaster.library's TCP/IP features, if you do not WANT to...
  1089.  
  1090.         RtgIoctl is a VERY CPU TIME INTENSIVE FUNCTION !!!
  1091.         Only call it during the INITIALIZATION of the network !!!
  1092.  
  1093.         My suggestion : Run the server in "blocking" mode, the Clients in
  1094.         "nonblocking" mode... seems to be the fastest...
  1095.  
  1096.    INPUTS
  1097.         SBase    - Result of the call (C Syntax here...)
  1098.                    SBase = OpenLibrary("bsdsocket.library",0);
  1099.         Socket   - The Socket of the application, which socket is to be modified
  1100.         arg      - "Non-Blocking" or "Blocking" (a pointer)
  1101.  
  1102.    RESULTS
  1103.         result   - 0 on success, -1 on fail (should not fail,normally...)
  1104.  
  1105.    SEE ALSO
  1106.         OpenClient(),OpenServer(),CloseClient(),CloseClient(),CloseServer(),RunServer(),RtgSend(),RtgAccept(),GetUDPName(),RtgInAdr()
  1107.  
  1108. rtgmaster.library/RtgOpenFont                              rtgmaster.library/RtgOpenFont
  1109.  
  1110.    NAME
  1111.         RtgOpenFont - opens an AmigaFont
  1112.  
  1113.    SYNOPSIS
  1114.         font = RtgOpenFont(RtgScreen,ta)
  1115.          D0                 A0       A1
  1116.  
  1117.         void * RtgOpenFont(struct RtgScreen *,struct TextAttr *)
  1118.  
  1119.    FUNCTION
  1120.         This function loads an AmigaFont to memory, for the usage on
  1121.         a RtgScreen, much the same way, like OpenDiskFont does for
  1122.         Intuition Screens. ta is a normal TextAttr pointer, like
  1123.         for OpenDiskFont for diskfont.library, but the RESULT
  1124.         is not for all WB Emulations a TextFont pointer. Don't use
  1125.         OpenDiskFont or OpenFont with rtgmaster.library, use
  1126.         RtgOpenFont, for the best possible compatibility with
  1127.         all Sublibraries !!!
  1128.  
  1129.    INPUTS
  1130.         RtgScreen - an RtgScreen
  1131.         ta        - a TextAttr structure, like defined in graphics/text.i (or .h)
  1132.  
  1133.    RESULTS
  1134.         font      - A pointer to a font pointer. It's internal structure is
  1135.                     PRIVATE to rtgmaster.library, and NOT THE SAME for all
  1136.                     sublibraries
  1137.  
  1138.    NOTES
  1139.         Not yet implemented for rtgPICA.library
  1140.  
  1141.    SEE ALSO
  1142.         RtgCloseFont(),RtgSetFont(),RtgSetTextMode(),RtgText(),RtgSetTextModeRGB
  1143.  
  1144. rtgmaster.library/RtgRecv                                  rtgmaster.library/RtgRecv
  1145.  
  1146.    NAME
  1147.         RtgRecv - The Socket of this application receives data from a connected socket
  1148.  
  1149.    SYNOPSIS
  1150.         length = RtgRecv(SBase,Socket,message,sender,len)
  1151.          D0               A0    A1     A2      A3     D0
  1152.  
  1153.         int RtgRecv(struct Library *,struct RTG_Socket *,struct char *,struct sockaddr_in *,int)
  1154.  
  1155.    FUNCTION
  1156.         This function is no longer compatible to rtgmaster.library V6 and below !!!
  1157.  
  1158.         This function gets data to the application that is sent to its socket by a socket
  1159.         that is connected to the socket of the Application (it is not that difficult to
  1160.         understand like it sounds... read the docs :) )
  1161.  
  1162.         If the "virtual connection" (or the "connectionless connection" or what this is called
  1163.         for UDP... :) ) is "blocking", it WAITS, if there is no message available
  1164.         on the socket, till one is available. If it is "non-blocking", it returns -1, if no
  1165.         message is available (see RtgIoctl for more details about "blocking" and "Non-Blocking".
  1166.         The default is "Blocking", BTW...)
  1167.  
  1168.         Sender is a special structure that you can use to find out from what IP Address
  1169.         the message was sent. You can convert it to an IP Address using RtgInAdr. This
  1170.         only works with UDP (with TCP, you differentiate Clients from each other with the
  1171.         socket number...). Appearently, you CAN'T differentiate Clients that run on the
  1172.         same machine !!! Sender is NOT allocated by the function, you have to provide
  1173.         the structure...
  1174.  
  1175.         For TCP you simple provide a 0 for Sender. It will be ignored.
  1176.  
  1177.         You can use this feature to do multiple connection without using RunServer (that
  1178.         does not support UDP up to now anyways...).
  1179.  
  1180.         NOTE: For *TCP* you provide the Socket of the Application which you want to
  1181.         contact. For *UDP* you provide your OWN'S Socket. Important difference !!!
  1182.  
  1183.         NOTE: It might appear strange to you, that you have to open bsdsocket.library
  1184.         yourselves and provide it as parameter. This is needed because of some internal
  1185.         problems of AmiTCP, that make it IMPOSSIBLE opening it inside a library. Look
  1186.         at the Docs for more information.
  1187.  
  1188.         You do NOT have to use rtgmaster.library's Graphics Board features to
  1189.         use rtgmaster.library's TCP/IP features, if you do not WANT to...
  1190.  
  1191.         NOTE: It is NOT possible to give Socket->s (the Socket Number) of a Client
  1192.         to the Server using RtgRecv or RunServer !!! You will have to examine
  1193.         inbuffer->num[x] to find out which Socket was the Sender !!! Also len
  1194.         should NEVER be bigger than the actual message, or you might get a lot
  1195.         of strange results !!!
  1196.  
  1197.    INPUTS
  1198.         SBase    - Result of the call (C Syntax here...)
  1199.                    SBase = OpenLibrary("bsdsocket.library",0);
  1200.         Socket   - The Socket of THIS application
  1201.         message  - The buffer, to which supplied messages will be put
  1202.         Sender   - The Function will fill in data about the Sender to this structure.
  1203.         len      - The length of the message to wait for
  1204.  
  1205.    RESULTS
  1206.         length   - The length of the message received. If it is smaller
  1207.                    than the message, you waited for, do a RtgRecv once more...
  1208.                    NOTE: If a message was received that is too long to fit to
  1209.                    the buffer, some Bytes might be discarded. So you should
  1210.                    not send more Bytes than you want to receive... use a standard
  1211.                    Package Size at best...
  1212.     SEE ALSO
  1213.         OpenClient(),CloseClient(),CloseClient(),CloseServer(),RunServer(),RtgSend(),RtgAccept(),RtgIoctl(),GetUDPName(),RtgInAdr()
  1214.  
  1215. rtgmaster.library/RtgScreenAtFront                         rtgmaster.library/RtgScreenAtFront
  1216.  
  1217.    NAME
  1218.         RtgScreenAtFront - determines if a RtgScreen is at front
  1219.  
  1220.    SYNOPSIS
  1221.         boolean = RtgScreenAtFront(RtgScreen)
  1222.                                     A0
  1223.  
  1224.         RtgScreenAtFront(struct RtgScreen *)
  1225.  
  1226.    FUNCTION
  1227.         This function should determine if this RtgScreen is currently at
  1228.         front.  It should return TRUE (0xfffffff) if the screen is in front
  1229.         of all other screens, and FALSE (0) if the screen is behind (partially
  1230.         or completely) an other screen.
  1231.  
  1232.         Note that this function will not be heavily reliable, since the user
  1233.         might switch screens at any time.
  1234.  
  1235.    INPUTS
  1236.         RtgScreen - A handle for a valid screen previously opened by
  1237.                     this sublibrary's OpenRtgScreen() function.
  1238.  
  1239.    RESULTS
  1240.         boolean - TRUE if screen is at front, FALSE otherwise.
  1241.  
  1242.    SEE ALSO
  1243.         OpenRtgScreen()
  1244.  
  1245. rtgmaster.library/RtgScreenModeReq                        rtgmaster.library/RtgScreenModeReq
  1246.  
  1247.    NAME
  1248.         RtgScreenModeReq -- Opens a ScreenMode requester
  1249.  
  1250.    SYNOPSIS
  1251.         ScreenReq = RtgScreenModeReq(ScreenModeTags)
  1252.          D0                           A0
  1253.  
  1254.         struct ScreenReq *RtgScreenModeReq(struct TagItem *)
  1255.  
  1256.    FUNCTION
  1257.         Opens a ScreenMode requester which displays all available
  1258.         ScreenModes to the user, depending on the Tags which are passed
  1259.         to this function.  The functions returns a pointer to a
  1260.         ScreenReq structure or NULL for failure or if the user
  1261.         cancelled the requester.
  1262.  
  1263.         The ScreenReq holds various information which the user selected,
  1264.         like width, height, screenmode and depth.
  1265.  
  1266.         THIS FUNCTION IS ONLY IN THE MASTER-LIBRARY. It handles the Screenmodes
  1267.         for ALL sublibraries.
  1268.  
  1269.         Note: The Screenmode-Requester provided with an early Beta of the
  1270.         rtgmaster.library was VERY buggy. It got completely replaced by
  1271.         a new one for this version of the library.
  1272.  
  1273.    INPUTS
  1274.         ScreenModeTags - Pointer to (an array of) TagItem structures,
  1275.                          terminated by the value TAG_END (0).
  1276.  
  1277.         The description for the various tags can be found in the .i/.h
  1278.         file (smr_Tags). NOTE: The Tags changed a lot since the early
  1279.         Beta release of the library.
  1280.  
  1281.    RESULTS
  1282.         ScreenReq - A pointer to a ScreenReq structure or NULL for
  1283.                     failure
  1284.  
  1285.    SEE ALSO
  1286.         OpenRtgScreen(),FreeRtgScreenModeReq()
  1287.  
  1288. rtgmaster.library/RtgSend                                  rtgmaster.library/RtgSend
  1289.  
  1290.    NAME
  1291.         RtgSend - The Socket of this application sends data to a connected socket
  1292.  
  1293.    SYNOPSIS
  1294.         length = RtgSend(SBase,Socket,message,Receiver,len)
  1295.          D0               A0    A1     A2      A3       D0
  1296.  
  1297.         int RtgSend(struct Library *,struct RTG_Socket *,struct char *,struct sockaddr_in *,int)
  1298.  
  1299.    FUNCTION
  1300.         This function is no longer compatible to rtgmaster.library V6 and below !!!
  1301.  
  1302.         This function puts data from the application to the socket of an application
  1303.         that is connected to the socket of the Application (it is not that difficult to
  1304.         understand like it sounds... read the docs :) )
  1305.  
  1306.         If the "virtual connection" (well, this term does not fit for UDP, as it is
  1307.         connectionless, but i do not know how to call it else... :) ) is "blocking", it WAITS, if there is no message available
  1308.         on the socket, till one is available. If it is "non-blocking", it returns -1, if no
  1309.         message is available (see RtgIoctl for more details about "blocking" and "Non-Blocking".
  1310.         The default is "Blocking", BTW...)
  1311.  
  1312.         Receiver is a special structure that you can use to tell the receiver your IP Address.
  1313.         You get your IP Address with GetUDPName (works only for UDP... for TCP this returns
  1314.         0...). For TCP you provide simply 0 for Receiver, it will be ignored.
  1315.         You can convert it to an IP Address using RtgInAdr. This
  1316.         only works with UDP (with TCP, you differentiate Clients from each other with the
  1317.         socket number...). Appearently, you CAN'T differentiate Clients that run on the
  1318.         same machine !!!
  1319.  
  1320.         You can use this feature to do multiple connection without using RunServer (that
  1321.         does not support UDP up to now anyways...).
  1322.  
  1323.         NOTE: For *TCP* you provide the Socket of the Application which you want to
  1324.         contact. For *UDP* you provide your OWN'S Socket. Important difference !!!
  1325.  
  1326.         NOTE: It might appear strange to you, that you have to open bsdsocket.library
  1327.         yourselves and provide it as parameter. This is needed because of some internal
  1328.         problems of AmiTCP, that make it IMPOSSIBLE opening it inside a library. Look
  1329.         at the Docs for more information.
  1330.  
  1331.         You do NOT have to use rtgmaster.library's Graphics Board features to
  1332.         use rtgmaster.library's TCP/IP features, if you do not WANT to...
  1333.  
  1334.         NOTE: It is NOT possible to give Socket->s (the Socket Number) of a Client
  1335.         to the Server using RtgRecv or RunServer !!! You will have to examine
  1336.         inbuffer->num[x] to find out which Socket was the Sender !!! Also len
  1337.         should NEVER be bigger than the actual message, or you might get a lot
  1338.         of strange results !!!
  1339.  
  1340.    INPUTS
  1341.         SBase    - Result of the call (C Syntax here...)
  1342.                    SBase = OpenLibrary("bsdsocket.library",0);
  1343.         Socket   - The Socket of THIS application
  1344.         message  - The message to be sent (an ASCII string, actually...)
  1345.         Receiver - The data you got from GetUDPName, tells the receiver your IP address...
  1346.         len      - The length of the string to send ...
  1347.  
  1348.    RESULTS
  1349.         length   - The length of the message sent. If it is smaller
  1350.                    than the message, you sent, do a RtgSend once more...
  1351.                    Probably the socket you sent to was quite busy with other
  1352.                    messages currently...
  1353.  
  1354.                    NOTE: If the send fails at all, maybe your message was too
  1355.                    long for TCP/IP ? (As to the allowed package sizes, 1 KB works
  1356.                    for sure... i do not know exactly how much more is possible...)
  1357.  
  1358.     SEE ALSO
  1359.         OpenClient(),CloseClient(),CloseClient(),CloseServer(),RunServer(),RtgRecv(),RtgAccept(),RtgIoctl(),GetUDPName(),RtgInAdr()
  1360.  
  1361. rtgmaster.library/RtgSetFont                              rtgmaster.library/RtgSetFont
  1362.  
  1363.    NAME
  1364.         RtgSetFont - sets an AmigaFont to an RtgScreen
  1365.  
  1366.    SYNOPSIS
  1367.         RtgSetFont(RtgScreen,font)
  1368.                     A0        A1
  1369.  
  1370.         void RtgSetFont(struct RtgScreen *,void *)
  1371.  
  1372.    FUNCTION
  1373.         This function sets an AmigaFont (that was opened using
  1374.         RtgOpenFont tomemory before) to an RtgScreen. Following
  1375.         RtgText() calls will use this font, now.
  1376.  
  1377.    INPUTS
  1378.         RtgScreen - an RtgScreen
  1379.         font      - a Font pointer. the structure of it is PRIVATE
  1380.                     to rtgmaster.library (and not the same for all
  1381.                     sublibraries...)
  1382.  
  1383.    NOTES
  1384.         Not yet implemented for rtgPICA.library
  1385.  
  1386.    SEE ALSO
  1387.         RtgOpenFont(),RtgCloseFont(),RtgSetTextMode(),RtgText(),RtgSetTextModeRGB
  1388.  
  1389. rtgmaster.library/RtgSetPointer                           rtgmaster.library/RtgSetPointer
  1390.  
  1391.    NAME
  1392.         RtgSetPointer - sets the pointer to a new image
  1393.  
  1394.    SYNOPSIS
  1395.         RtgSetPointer(RtgScreen,pointer,Width,Height,OffsetX,OffsetY)
  1396.                          A0      A1      D0    D1     D2      D3
  1397.  
  1398.         void RtgSetPointer(struct RtgScreen *,UWORD *,WORD,WORD,WORD,WORD)
  1399.  
  1400.    FUNCTION
  1401.         This function sets the mousepointer to a new image for this RtgScreen.
  1402.         The structure pointer is exactly the same like taken from intuition.library
  1403.         command SetPointer (the data definition of a Simple Sprite). Different
  1404.         from this only is that the image HAS TO BE 16x18 pixels size. If you
  1405.         want a smaller pointer, modify the Width/Height values and set that
  1406.         pixels that you do not need to 0. But the SIZE of the structure has
  1407.         to be 16x18 pixels (72 Bytes). An example :
  1408.  
  1409.         UWORD Hoehe[2]
  1410.         {
  1411.             0x...,0x... // first line
  1412.             ...
  1413.             0x...,0x... // 18th line
  1414.         }
  1415.  
  1416.         Look at graphics.library SimpleSprite documentation for more information
  1417.         (01,10,11 are the three pointer colors,00 is transperent, each of
  1418.         the two words of a line determines ONE BIT of the 2-Bit mousepointer).
  1419.  
  1420.    INPUTS
  1421.         RtgScreen - The RtgScreen, which pointer should be resetted...
  1422.         pointer   - pointer image, see above
  1423.         Width     - Actual Width of the pointer
  1424.         Height    - Actual Height of the pointer
  1425.         OffsetX   - Display Offset for the pointer, from the mouseposition
  1426.         OffsetY   - Display Offset for the pointer, from the mouseposition
  1427.  
  1428.    NOTES
  1429.        Not implemented yet on rtgPICA.library and rtgEGS.library
  1430.  
  1431.        Do NOT specifically demand Chipram for the pointer array.
  1432.        Else your program won't run on the DraCo. rtgmaster.library will
  1433.        handle this itself, that the pointer-image will end in
  1434.        Chipram for ECS/AGA, in ANYTHING AVAILABLE on GFX Board system.
  1435.        So simply allocate RAM for the pointer image, without simply
  1436.        demanding Chipram or Fastram (as DraCo needs FastRam, and
  1437.        ECS/AGA need Chipram here... but well... rtgmaster.library
  1438.        takes care of this :) )
  1439.  
  1440.    SEE ALSO
  1441.        RtgClearPointer()
  1442.  
  1443. rtgmaster.library/RtgGetMsg                             rtgmaster.library/RtgGetMsg
  1444.  
  1445.    NAME
  1446.         RtgGetMsg - replies the message on an RDCMP
  1447.  
  1448.    SYNOPSIS
  1449.         imsg = RtgGetMsg(RtgScreen)
  1450.          d0               a0
  1451.  
  1452.         void *RtgGetMsg(struct RtgScreen *)
  1453.  
  1454.    FUNCTION
  1455.         Gets the latest message of a RDCMP. RDCMP uses the
  1456.         structures of the IntuiMessage of intuition (but note,
  1457.         this is NOT an IDCMP... it only simulates the structures
  1458.         of the IDCMP !!!)
  1459.         List of the structures for those guys without OS includes
  1460.         (look at intuition/intuition.h or .i) (ASM notation, as
  1461.         C guys usually HAVE OS includes...)
  1462.  
  1463.         STRUCTURE IntuiMessage,0
  1464.  
  1465.          STRUCT im_ExecMessage,mn_SIZE
  1466.  
  1467.          LONG im_Class
  1468.  
  1469.          // For rtgmaster this is IDCMP_MOUSEBUTTONS or
  1470.          // IDCMP_RAWKEY, as RDCMP only supports mousebuttons
  1471.          // or keyboard events... look at this field to examine
  1472.          // which event happened...
  1473.  
  1474.          WORD im_Code
  1475.  
  1476.          // For Keyboard events, here the Rawkey value of the pressed
  1477.          // key is found... Bit 7 handles Keydown/Keyup, like usual...
  1478.  
  1479.          // For mouse : SELECTUP,SELECTDOWN,...
  1480.  
  1481.          WORD im_Qualifier
  1482.  
  1483.          // The Qualifiers for CTRL,SHIFT,... each qualifier has a bit...
  1484.  
  1485.          APTR im_IAddress
  1486.  
  1487.          WORD im_MouseX
  1488.          WORD im_MouseY
  1489.  
  1490.          // Mouseposition, when the event happened...
  1491.  
  1492.          LONG im_Seconds
  1493.          LONG im_Micros
  1494.  
  1495.          // systemtime, when the event happened
  1496.  
  1497.          APTR im_IDCMPWindow
  1498.  
  1499.          // Well, undefined for RDCMP, as rtgmaster not
  1500.          // always uses Intuition :)
  1501.  
  1502.          APTR im_SpecialLink
  1503.  
  1504.         // Well... usually undefined for RDCMP... don't acces
  1505.         // it...
  1506. };
  1507.  
  1508.         IDCMP_MOUSEBUTTONS EQU 8
  1509.         IDCMP_RAWKEY EQU 1024
  1510. SELECTUP        EQU     (IECODE_LBUTTON+IECODE_UP_PREFIX)
  1511. SELECTDOWN      EQU     (IECODE_LBUTTON)
  1512. MENUUP          EQU     (IECODE_RBUTTON+IECODE_UP_PREFIX)
  1513. MENUDOWN        EQU     (IECODE_RBUTTON)
  1514. MIDDLEUP        EQU     (IECODE_MBUTTON+IECODE_UP_PREFIX)
  1515. MIDDLEDOWN      EQU     (IECODE_MBUTTON)
  1516.  
  1517. out of devices/inputevents.i :
  1518.  
  1519. IECODE_LBUTTON                  EQU     $68     ; also uses IECODE_UP_PREFIX
  1520. IECODE_RBUTTON                  EQU     $69     ;
  1521. IECODE_MBUTTON                  EQU     $6A     ;
  1522.  
  1523. IEQUALIFIER_LSHIFT              EQU     $0001
  1524. IEQUALIFIER_RSHIFT              EQU     $0002
  1525. IEQUALIFIER_CAPSLOCK            EQU     $0004
  1526. IEQUALIFIER_CONTROL             EQU     $0008
  1527. IEQUALIFIER_LALT                EQU     $0010
  1528. IEQUALIFIER_RALT                EQU     $0020
  1529. IEQUALIFIER_LCOMMAND            EQU     $0040
  1530. IEQUALIFIER_RCOMMAND            EQU     $0080
  1531. IEQUALIFIER_MIDBUTTON           EQU     $1000
  1532. IEQUALIFIER_RBUTTON             EQU     $2000
  1533. IEQUALIFIER_LEFTBUTTON          EQU     $4000
  1534.  
  1535. but well, simply include the two OS includes, and you won't have to
  1536. bother about this stuff... :)
  1537.  
  1538.    INPUTS
  1539.         RtgScreen - The Screen, which port is to be used
  1540.  
  1541.    NOTES
  1542.        DOES NOT RUN ON rtgPICA.library up to now !!!
  1543.        RDCMP supports both waiting and polling !!!
  1544.        As to my experiences, better use RDCMP than anything else...
  1545.        other methods i tried tended to lose mouseclicks, if
  1546.        they came very fast, and if the application took a lot
  1547.        of processing time. RDCMP does not lose data.
  1548.        Information about polling : See docs of RtgWaitRDCMP
  1549.  
  1550.    SEE ALSO
  1551.         RtgWaitRDCMP(),RtgInitRDCMP(),RtgReplyMsg()
  1552.  
  1553. rtgmaster.library/RtgReplyMsg                             rtgmaster.library/RtgReplyMsg
  1554.  
  1555.    NAME
  1556.         RtgReplyMsg - replies the message on an RDCMP
  1557.  
  1558.    SYNOPSIS
  1559.         RtgReplyMsg(RtgScreen, imsg)
  1560.                      a0        a1
  1561.  
  1562.         void RtgReplyMsg(struct RtgScreen *,void *)
  1563.  
  1564.    FUNCTION
  1565.         Replies the message on a RDCMP and tells the port, that the
  1566.         message can be deleted now. Save all values of the message that
  1567.         you need before this !!! Don't access the structure itself
  1568.         after the reply !!!
  1569.  
  1570.    INPUTS
  1571.         RtgScreen - The Screen, which port is to be used
  1572.         imsg - the messages to be replied
  1573.  
  1574.    NOTES
  1575.        DOES NOT RUN ON rtgPICA.library up to now !!!
  1576.        RDCMP supports both waiting and polling !!!
  1577.        As to my experiences, better use RDCMP than anything else...
  1578.        other methods i tried tended to lose mouseclicks, if
  1579.        they came very fast, and if the application took a lot
  1580.        of processing time. RDCMP does not lose data.
  1581.  
  1582.    SEE ALSO
  1583.         RtgWaitRDCMP(),RtgInitRDCMP(),RtgGetMsg()
  1584.  
  1585.  
  1586. rtgmaster.library/RtgSetTextMode                              rtgmaster.library/RtgSetTextMode
  1587.  
  1588.    NAME
  1589.         RtgSetTextMode - sets text color and drawing mode
  1590.  
  1591.    SYNOPSIS
  1592.         RtgSetTextMode(RtgScreen,fgcolor,bgcolor,drmode)
  1593.                         A0        D0      D1      D2
  1594.  
  1595.         void RtgSetTextMode(struct RtgScreen *,UBYTE,UBYTE,UBYTE)
  1596.  
  1597.    FUNCTION
  1598.         Sets the foreground color, the background color and the drawing
  1599.         mode for Text on this RtgScreen.  drmodes are defined as usual
  1600.         in graphics/rastport.i (or .h) : JAM1, JAM2, COMPLEMENT.
  1601.         INVERSVID is not valid...
  1602.  
  1603.         This function should only be used on Displays with depth <=8.
  1604.  
  1605.    INPUTS
  1606.         RtgScreen - an RtgScreen
  1607.         fgcolor   - Foreground color
  1608.         bgcolor   - Background color
  1609.         drwmode   - Drawing mode, defined in graphics/rastport.i (or .h)
  1610.  
  1611.    NOTES
  1612.         Not yet implemented for rtgPICA.library
  1613.  
  1614.    SEE ALSO
  1615.         RtgOpenFont(),RtgSetFont(),RtgCloseFont(),RtgText(),RtgSetTextModeRGB()
  1616.  
  1617.  
  1618. rtgmaster.library/RtgSetTextModeRGB                              rtgmaster.library/RtgSetTextModeRGB
  1619.  
  1620.    NAME
  1621.         RtgSetTextModeRGB - sets text color and drawing mode for depths >8
  1622.  
  1623.    SYNOPSIS
  1624.         RtgSetTextModeRGB(RtgScreen,fgcolor,bgcolor,drmode)
  1625.                         A0        D0      D1      D2
  1626.  
  1627.         void RtgSetTextModeRGB(struct RtgScreen *,ULONG,ULONG,UBYTE)
  1628.  
  1629.    FUNCTION
  1630.         Sets the foreground color, the background color and the drawing
  1631.         mode for Text on this RtgScreen.  drmodes are defined as usual
  1632.         in graphics/rastport.i (or .h) : JAM1, JAM2, COMPLEMENT.
  1633.         INVERSVID is not valid...
  1634.  
  1635.         Should only be used on Displays with depth >8.
  1636.  
  1637.    NOTES
  1638.         Due to a bug in CyberGraphX, this function does not work
  1639.         very well with rtgCGX.library (strange colors...). Not yet
  1640.         implemented in rtgPICA.library.
  1641.  
  1642.    INPUTS
  1643.         RtgScreen - an RtgScreen
  1644.         fgcolor   - Foreground color
  1645.         bgcolor   - Background color
  1646.         drwmode   - Drawing mode, defined in graphics/rastport.i (or .h)
  1647.  
  1648.  
  1649.    SEE ALSO
  1650.         RtgOpenFont(),RtgSetFont(),RtgCloseFont(),RtgText(),RtgSetTextMode()
  1651.  
  1652.  
  1653. rtgmaster.library/RtgText                              rtgmaster.library/RtgText
  1654.  
  1655.    NAME
  1656.         RtgText - displays Text on an RtgScreen
  1657.  
  1658.    SYNOPSIS
  1659.         RtgText(RtgScreen,buffer,string,length,xpos,ypos)
  1660.                  A0        A1     A2     D0     D1   D2
  1661.  
  1662.         void RtgText(struct RtgScreen *,void *,char *,WORD,SHORT,SHORT)
  1663.  
  1664.    FUNCTION
  1665.         Displays the string "string" with the chosen font parameters (see
  1666.         RtgSetFont(), RtgSetTextMode(), RtgSetTextModeRGB() ) at position
  1667.         xpos,ypos much the same way like Text() of graphics.library does.
  1668.  
  1669.    INPUTS
  1670.         RtgScreen - an RtgScreen
  1671.         buffer    - The buffer address of the buffer where to display the text
  1672.         string    - pointer to a string
  1673.         length    - length of the string in characters
  1674.         xpos      - the x-pos
  1675.         ypos      - the y-pos
  1676.  
  1677.    NOTES
  1678.         Not yet implemented for rtgPICA.library.
  1679.  
  1680.    SEE ALSO
  1681.         RtgOpenFont(),RtgSetFont(),RtgCloseFont(),RtgCloseFont(),RtgSetTextModeRGB(),RtgSetTextMode()
  1682.  
  1683. rtgmaster.library/RtgWaitRDCMP                             rtgmaster.library/RtgWaitRDCMP
  1684.  
  1685.    NAME
  1686.         RtgWaitRDCMP - Waits on a message on the RDCMP of the Screen
  1687.  
  1688.    SYNOPSIS
  1689.         RtgWaitRDCMP(RtgScreen)
  1690.                      a0
  1691.  
  1692.         void RtgWaitRDCMP(struct RtgScreen *)
  1693.  
  1694.    FUNCTION
  1695.         Waits on a message on the RDCMP. If you don't want your
  1696.         application to WAIT while the user is giving no inputs
  1697.         (well, it usually should NOT wait for games...), use polling :
  1698.  
  1699.         1. Open the Screen and init its RDCMP
  1700.         2. Inside the loop, do RtgGetMsg
  1701.         3. If imsg->Class is RDCMP_MOUSEBUTTONS or
  1702.            RDCMP_RAWKEY, handle the message and reply it
  1703.            using RtgReplyMsg
  1704.         4. Else don't reply it (if you reply a message when there
  1705.            in fact is NO MESSAGE, you might crash the system !!!)
  1706.  
  1707.    INPUTS
  1708.         RtgScreen - The Screen, which port is to be used
  1709.  
  1710.    NOTES
  1711.        DOES NOT RUN ON rtgPICA.library up to now !!!
  1712.  
  1713.    SEE ALSO
  1714.         RtgInitRDCMP(),RtgGetMsg(),RtgReplyMsg()
  1715.  
  1716.  
  1717. rtgmaster.library/RtgWaitTOF                                  rtgmaster.library/RtgWaitTOF
  1718.  
  1719.    NAME
  1720.         RtgWaitTOF - Wait for the top of the next video frame.
  1721.  
  1722.    SYNOPSIS
  1723.         WaitTOF(RtgScreen)
  1724.                  A0
  1725.  
  1726.         WaitTOF(struct RtgScreen *)
  1727.  
  1728.    FUNCTION
  1729.         Wait  for vertical blank to occur and all vertical blank
  1730.         interrupt routines to complete before returning to caller.
  1731.  
  1732.         Does not do anything at all with some sublibraries... (CyberGraphX does not
  1733.         support TOF-Waiting up to now...)
  1734.  
  1735.    INPUTS
  1736.         The Screen Handle of the GFX Board Screen (only in FACT needed for rtgEGS.library,
  1737.         and probably nothing much is done about it anyway... but be nice... give this
  1738.         parameter... to stay compatible :) )
  1739.  
  1740.    RESULTS
  1741.         Places this task on the TOF wait queue. When the vertical blank
  1742.         interrupt comes around, the interrupt service routine will fire off
  1743.         signals to all the tasks doing WaitTOF. The highest priority task
  1744.         ready will get to run then.
  1745.  
  1746.    SEE ALSO
  1747.        graphics.library/WaitTOF()
  1748.  
  1749. rtgmaster.library/RunServer                                      rtgmaster.library/RunServer
  1750.  
  1751.    NAME
  1752.         RunServer -- Handle all the messaging for a server and several clients
  1753.  
  1754.    SYNOPSIS
  1755.         New_Socket = RunServer(SBase,Socket,in_buffer,out_buffer,maxplayers)
  1756.          D0                     A0    A1     A2        A3         D0
  1757.  
  1758.         struct RTG_Socket *RunServer(struct Library *,struct RTG_Socket *,struct RTG_Buff *,struct RTG_Buff *,int)
  1759.  
  1760.    FUNCTION
  1761.         You will have to run this fine
  1762.         function in a loop. Every time it returns, it gives you the Socket of a new connected
  1763.         client or 0, if no new Client connected. Also, in  in_buffer, you will have all new
  1764.         messages sent from  already connected Clients to the server, and all messages you filled
  1765.         in in out_buffer before calling this function, will be sent to the Clients.
  1766.         If nothing happened, this function returns at once, with consuming nearly no CPU time.
  1767.  
  1768.         You SHOULD initialize the in_buffer.num values with -1 EACH TIME, before
  1769.         RunServer is run, and the out_buffer.num values once before the FIRST TIME
  1770.         RunServer is called !!!
  1771.  
  1772.         NOTE: If you (later...) use RunServer, the Server can't handle a Player. You need
  1773.         ONE CLIENT PER PLAYER AND AN ADDITIONAL SERVER WITHOUT A PLAYER. The Server can run
  1774.         on a system, where a Client is also running, though (should be the fastest system in
  1775.         the connection, probably, as it will have to do all that messaging to the Client ...)
  1776.  
  1777.         NOTE: It might appear strange to you, that you have to open bsdsocket.library
  1778.         yourselves and provide it as parameter. This is needed because of some internal
  1779.         problems of AmiTCP, that make it IMPOSSIBLE opening it inside a library. Look
  1780.         at the Docs for more information.
  1781.  
  1782.         You do NOT have to use rtgmaster.library's Graphics Board features to
  1783.         use rtgmaster.library's TCP/IP features, if you do not WANT to...
  1784.  
  1785.         NOTE: It is NOT possible to give Socket->s (the Socket Number) of a Client
  1786.         to the Server using RtgRecv or RunServer !!! You will have to examine
  1787.         inbuffer->num[x] to find out which Socket was the Sender !!! Also len
  1788.         should NEVER be bigger than the actual message, or you might get a lot
  1789.         of strange results !!!
  1790.  
  1791.         NOTE: UP TO NOW (rtgmaster Version 7) ONLY SUPPORTS TCP... NO UDP SUPPORT UP TO NOW !!!
  1792.  
  1793.    INPUTS
  1794.         SBase      - Result of the call (C Syntax here...)
  1795.                      SBase = OpenLibrary("bsdsocket.library",0);
  1796.         Socket     - The Socket of THIS application (the Server...)
  1797.         in_buffer  - messages that arrived during the call of RunServer
  1798.         out_buffer - messages that Run_Server should deliver
  1799.         maxplayers - The Maximum of Clients allowed (CAN'T BE BIGGER THAN 12 !!!)
  1800.  
  1801.    RESULTS
  1802.         New_Socket - The Socket of a newly connected Client. Save it somewhere...
  1803.  
  1804.    SEE ALSO
  1805.         OpenClient(),CloseClient(),CloseClient(),CloseServer(),RunServer(),RtgRecv(),RtgSend(),RtgAccept(),RtgIoctl(),GetUDPName(),RtgInAdr()
  1806.  
  1807. rtgmaster.library/SetSegment                                     rtgmaster.library/SetSegment
  1808.  
  1809.    NAME
  1810.         SetSegment -- set the active segment
  1811.  
  1812.    SYNOPSIS
  1813.         SetSegment(segnum)
  1814.                     D0
  1815.  
  1816.         SetSegment(ULONG)
  1817.  
  1818.    FUNCTION
  1819.         If the graphic board works in segment mode -- with a
  1820.         memory window of 64 KByte -- a call to SetSegment() sets
  1821.         the active segment to the supplied number.
  1822.  
  1823.         If the graphic board works non-segmented, a call to this
  1824.         function has no effect.
  1825.  
  1826.    INPUTS
  1827.         segnum - number of segment
  1828.  
  1829.    SEE ALSO
  1830.         GetSegment()
  1831.  
  1832.  
  1833.  
  1834. rtgmaster.library/SwitchScreens                              rtgmaster.library/SwitchScreens
  1835.  
  1836.    NAME
  1837.         SwitchScreens -- Perform doublebuffering
  1838.  
  1839.    SYNOPSIS
  1840.         SwitchScreens(RtgScreen, Buffer)
  1841.                        A0         D0
  1842.  
  1843.         SwitchScreens(ULONG, ULONG)
  1844.  
  1845.    FUNCTION
  1846.         RtgScreen passed in A0 is a handle of a screen previously opened
  1847.         by OpenRtgScreen().
  1848.  
  1849.         This functions is used to specify the buffer which should
  1850.         be displayed starting from the next Vertical Blank.  The buffer
  1851.         supplied is a simple number (0 = first buffer, 1 = 2nd buffer
  1852.         etcetera).
  1853.  
  1854.         If the same buffer is being specified as is being displayed then
  1855.         this function should do nothing.
  1856.  
  1857.         This function will never be called from interupts.
  1858.  
  1859.    INPUTS
  1860.         RtgScreen - A handle for a valid screen previously opened by
  1861.                     this sublibrary's OpenRtgScreen() function.
  1862.         Buffer - The buffer number the user wishes to display
  1863.  
  1864.    SEE ALSO
  1865.         OpenRtgScreen(),WaitRtgSwitch()
  1866.  
  1867.  
  1868.  
  1869. rtgmaster.library/UnlockRtgScreen                          rtgmaster.library/UnlockRtgScreen
  1870.  
  1871.    NAME
  1872.         UnlockRtgScreen -- Unlocks a RtgScreen
  1873.  
  1874.    SYNOPSIS
  1875.         UnlockRtgScreen(RtgScreen)
  1876.                          A0
  1877.  
  1878.         UnlockRtgScreen(ULONG)
  1879.  
  1880.    FUNCTION
  1881.         Unlocks a previously locked RtgScreen.  If this screen hasn't
  1882.         been locked before this function will do nothing.
  1883.  
  1884.         LockRtgScreen() and UnlockRtgScreen() functions nest, which means
  1885.         the user must call an UnlockRtgScreen() for every LockRtgScreen().
  1886.         If not the user will end up with a permenantly locked screen.
  1887.  
  1888.    INPUTS
  1889.         RtgScreen - A handle for a valid screen previously opened by
  1890.                     this sublibrary's OpenRtgScreen() function.
  1891.  
  1892.    SEE ALSO
  1893.         LockRtgScreen()
  1894.  
  1895. rtgmaster.library/WaitRtgBlit                                 rtgmaster.library/WaitRtgBlit
  1896.  
  1897.    NAME
  1898.         WaitRtgBlit - Waits on the Blitter to be finished
  1899.  
  1900.    SYNOPSIS
  1901.         WaitRtgBlit(RtgScreen)
  1902.                     A0
  1903.  
  1904.         WaitRtgBlit(struct RtgScreen *)
  1905.  
  1906.    FUNCTION
  1907.         Waits for the GFX Board Blitter to be finished. For those who wonder,
  1908.         why RtgScreen has to be given as parameter... it probably won't be used...
  1909.         just to be on the sure side :)
  1910.  
  1911.         Does not do anything at all with some sublibraries. Some of them ALWAYS wait...
  1912.  
  1913.    INPUTS
  1914.         RtgScreen - The RtgScreen structure
  1915.  
  1916.    SEE ALSO
  1917.         OpenRtgScreen(), RtgBlit()
  1918.  
  1919. rtgmaster.library/WaitRtgSwitch                               rtgmaster.library/WaitRtgSwitch
  1920.  
  1921.    NAME
  1922.         WaitRtgSwitch - Waits on Doublebuffering having happened
  1923.  
  1924.    SYNOPSIS
  1925.         WaitRtgSwitch(RtgScreen)
  1926.                     A0
  1927.  
  1928.         WaitRtgSwitch(struct RtgScreen *)
  1929.  
  1930.    FUNCTION
  1931.         As SwitchScreens does not wait till the Doublebuffering has happened,
  1932.         but returns AT ONCE, it might be that the program wants to access the
  1933.         video memory BEFORE the change has happened. In this case you can use
  1934.         WaitRtgSwitch to be sure the change really happened. If you do not
  1935.         want to wait, simply do not use this call :)
  1936.  
  1937.         Does not do much for some sublibraries. Some always wait...
  1938.  
  1939.    INPUTS
  1940.         The Screenhandle of the Screen, where the Wait should happen...
  1941.  
  1942.    SEE ALSO
  1943.         SwitchScreens()
  1944.  
  1945.  
  1946.  
  1947.  
  1948. rtgmaster.library/WriteRtgPixel                               rtgmaster.library/WriteRtgPixel
  1949.  
  1950.    NAME
  1951.         WriteRtgPixel - plots a single pixel to a RtgScreen
  1952.  
  1953.    SYNOPSIS
  1954.         WriteRtgPixel(RtgScreen, BufferAdr, XPos, YPos, Color)
  1955.                        A0         A1         D0    D1    D2
  1956.  
  1957.         WriteRtgPixel(struct RtgScreen *, APTR, ULONG, ULONG, UBYTE)
  1958.  
  1959.    FUNCTION
  1960.         Draws a single pixel at the specified position on a RtgScreen.
  1961.         The BufferAdr is the starting address of the buffer the users wants
  1962.         to draw the pixel in.  The user has obtained this address using
  1963.         LockRtgScreen() and GetBufAdr().  The BufferAdr is needed to specify
  1964.         the correct buffer for screens which are double or triple buffered.
  1965.  
  1966.         This function should only work for Palette mapped modes, Color is
  1967.         the Color number of the palette.
  1968.  
  1969.         THIS FUNCTION IS IMPLEMENTED WITH SUBLIBRARIES STARTING WITH VERSION 1.8
  1970.  
  1971.         DO NOT USE FOR SPEED RELEVANT STUFF. THIS FUNCTION MAY HAVE
  1972.         SOME OVERHEAD. FOR FAST OPERATIONS USE COPYRTGPIXELARRAY OR
  1973.         DO THE STUFF YOURSELVES.
  1974.  
  1975.    INPUTS
  1976.         RtgScreen - A handle for a valid screen previously opened by
  1977.                     this sublibrary's OpenRtgScreen() function.
  1978.         BufferAdr - The address of the memory containing the actual
  1979.                     screen graphics
  1980.         XPos - X position of the pixel the user wants to plot
  1981.         YPos - Y position of the pixel the user wants to plot
  1982.         Color - Color number
  1983.  
  1984.    SEE ALSO
  1985.         OpenRtgScreen(), WriteRtgPixelRGB(), WriteRtgPixelArray()
  1986.  
  1987.  
  1988.  
  1989. rtgmaster.library/WriteRtgPixelArray                     rtgmaster.library/WriteRtgPixelArray
  1990.  
  1991.    NAME
  1992.         WriteRtgPixelArray - writes an array of pixels to a RtgScreen
  1993.  
  1994.    SYNOPSIS
  1995.         WriteRtgPixelArray(RtgScreen, BufferAdr, Array, Left, Top, Width, Height)
  1996.                             A0         A1         A2     D0    D1   D2     D3
  1997.  
  1998.         WriteRtgPixelArray(struct RtgScreen *, APTR, APTR, ULONG, ULONG,
  1999.                            ULONG, ULONG)
  2000.  
  2001.    FUNCTION
  2002.         Draws an rectangular array of pixels to the specified position on a
  2003.         RtgScreen.  The BufferAdr is the starting address of the buffer the
  2004.         user wants to draw this array of pixels in.  The user has obtained
  2005.         this address using LockRtgScreen() and GetBufAdr().  The BufferAdr is
  2006.         needed to specify the correct buffer for screens which are double or
  2007.         triple buffered.
  2008.  
  2009.         This function should only work for Palette mapped modes.  The array
  2010.         consists of one byte per pixel, each byte specifying a Color number.
  2011.  
  2012.         This function is many times faster than writing each pixel seperately
  2013.         to the screen using WriteRtgPixel().
  2014.  
  2015.         Note: For compatibility with rtgAMI.library,
  2016.         Array should contain at least ((((width+15)>>4)<<4)*Height Bytes.
  2017.  
  2018.         THIS FUNCTION IS IMPLEMENTED WITH SUBLIBRARIES STARTING WITH VERSION 1.8
  2019.  
  2020.         DO NOT USE FOR SPEED RELEVANT STUFF. THIS FUNCTION MAY HAVE
  2021.         SOME OVERHEAD. FOR FAST OPERATIONS USE COPYRTGPIXELARRAY OR
  2022.         DO THE STUFF YOURSELVES.
  2023.  
  2024.    INPUTS
  2025.         RtgScreen - A handle for a valid screen previously opened by
  2026.                     this sublibrary's OpenRtgScreen() function.
  2027.         BufferAdr - The address of the memory containing the actual
  2028.                     screen graphics
  2029.         Array - Pointer to an array of pixels which is Width pixels wide, 
  2030.                 and Height pixels high.  Each pixel is one byte in size.
  2031.         Left - X position of the top-left of the rectangular pixel array
  2032.         Top - Y position of the top-left of the rectangular pixel array
  2033.         Width - Width of the array in pixels
  2034.         Height - Height of the array in pixels
  2035.  
  2036.    SEE ALSO
  2037.         OpenRtgScreen(), WriteRtgPixel(), WriteRtgPixelRGBArray()
  2038.  
  2039.  
  2040.  
  2041. rtgmaster.library/WriteRtgPixelRGB                         rtgmaster.library/WriteRtgPixelRGB
  2042.  
  2043.    NAME
  2044.         WriteRtgPixelRGB - plots a single pixel to a RtgScreen
  2045.  
  2046.    SYNOPSIS
  2047.         WriteRtgPixelRGB(RtgScreen, BufferAdr, XPos, YPos, Color)
  2048.                           A0         A1         D0    D1    D2
  2049.  
  2050.         WriteRtgPixelRGB(struct RtgScreen *, APTR, ULONG, ULONG, ULONG)
  2051.  
  2052.    FUNCTION
  2053.         Draws a single pixel at the specified position on a RtgScreen.
  2054.         The BufferAdr is the starting address of the buffer the users wants
  2055.         to draw the pixel in.  The user has obtained this address using
  2056.         LockRtgScreen() and GetBufAdr().  The BufferAdr is needed to specify
  2057.         the correct buffer for screens which are double or triple buffered.
  2058.  
  2059.         This function should only work for True Color modes, Color is
  2060.         a 32 bit value which specifies what Color the pixel should be.
  2061.         The layout of this 32-bit value is as follows:
  2062.  
  2063.         %aaaaaaaa.rrrrrrrr.gggggggg.bbbbbbbb        
  2064.  
  2065.         a = AlphaChannel (8-bits) which may or may not be ignored.  The
  2066.             user will set this to zero if the user doesn't want to use
  2067.             AlphaChannel.
  2068.         r = Red component (8-bits) of the 24-bit RGB value
  2069.         g = Green component (8-bits) of the 24-bit RGB value
  2070.         b = Blue component (8-bits) of the 24-bit RGB value
  2071.  
  2072.         THIS FUNCTION IS IMPLEMENTED WITH SUBLIBRARIES STARTING WITH VERSION 1.8
  2073.  
  2074.         DO NOT USE FOR SPEED RELEVANT STUFF. THIS FUNCTION MAY HAVE
  2075.         SOME OVERHEAD. FOR FAST OPERATIONS USE COPYRTGPIXELARRAY OR
  2076.         DO THE STUFF YOURSELVES.
  2077.  
  2078.    INPUTS
  2079.         RtgScreen - A handle for a valid screen previously opened by
  2080.                     this sublibrary's OpenRtgScreen() function.
  2081.         BufferAdr - The address of the memory containing the actual
  2082.                     screen graphics
  2083.         XPos - X position of the pixel the user wants to plot
  2084.         YPos - Y position of the pixel the user wants to plot
  2085.         Color - A 32-bit value describing the color (see above)
  2086.  
  2087.    SEE ALSO
  2088.         OpenRtgScreen(), WriteRtgPixel(), WriteRtgPixelRGBArray()
  2089.  
  2090.  
  2091.  
  2092. rtgmaster.library/WriteRtgPixelRGBArray               rtgmaster.library/WriteRtgPixelRGBArray
  2093.  
  2094.    NAME
  2095.         WriteRtgPixelRGBArray - writes an array of pixels to a RtgScreen
  2096.  
  2097.    SYNOPSIS
  2098.         WriteRtgPixelRGBArray(RtgScreen, BufferAdr, Array, Left, Top, Width, Height)
  2099.                                A0         A1         A2     D0    D1   D2     D3    
  2100.  
  2101.         WriteRtgPixelRGBArray(struct RtgScreen *, APTR, APTR, ULONG, ULONG,
  2102.                               ULONG, ULONG)
  2103.  
  2104.    FUNCTION
  2105.         Draws an rectangular array of pixels to the specified position on a
  2106.         RtgScreen.  The BufferAdr is the starting address of the buffer the
  2107.         user wants to draw this array of pixels in.  The user has obtained
  2108.         this address using LockRtgScreen() and GetBufAdr().  The BufferAdr is
  2109.         needed to specify the correct buffer for screens which are double or
  2110.         triple buffered.
  2111.  
  2112.         This function should only work for True Color modes.  The array
  2113.         consists of one longword (32-bits) per pixel, each longword specifies
  2114.         a Color in this format:
  2115.  
  2116.         %aaaaaaaa.rrrrrrrr.gggggggg.bbbbbbbb        
  2117.  
  2118.         a = AlphaChannel (8-bits) which may or may not be ignored.  The
  2119.             user will set this to zero if the user doesn't want to use
  2120.             AlphaChannel.
  2121.         r = Red component (8-bits) of the 24-bit RGB value
  2122.         g = Green component (8-bits) of the 24-bit RGB value
  2123.         b = Blue component (8-bits) of the 24-bit RGB value
  2124.  
  2125.         This function is many times faster than writing each pixel seperately
  2126.         to the screen using WriteRtgPixelRGB().
  2127.  
  2128.         THIS FUNCTION IS IMPLEMENTED WITH SUBLIBRARIES STARTING WITH VERSION 1.8
  2129.  
  2130.         DO NOT USE FOR SPEED RELEVANT STUFF. THIS FUNCTION MAY HAVE
  2131.         SOME OVERHEAD. FOR FAST OPERATIONS USE COPYRTGPIXELARRAY OR
  2132.         DO THE STUFF YOURSELVES.
  2133.  
  2134.    INPUTS
  2135.         RtgScreen - A handle for a valid screen previously opened by
  2136.                     this sublibrary's OpenRtgScreen() function.
  2137.         BufferAdr - The address of the memory containing the actual
  2138.                     screen graphics
  2139.         Array - Pointer to an array of pixels which is Width pixels wide, 
  2140.                 and Height pixels high.  Each pixel is one longword (32-bits)
  2141.                 in size.
  2142.         Left - X position of the top-left of the rectangular pixel array
  2143.         Top - Y position of the top-left of the rectangular pixel array
  2144.         Width - Width of the array in pixels
  2145.         Height - Height of the array in pixels
  2146.  
  2147.    SEE ALSO
  2148.         OpenRtgScreen(), WriteRtgPixelRGB(), WriteRtgPixelArray()
  2149.